home *** CD-ROM | disk | FTP | other *** search
/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / networking / osi / x500 / quipu-patches / kerberos / kerberos.patch < prev    next >
Encoding:
Text File  |  1993-04-27  |  25.5 KB  |  935 lines
  1. *** dsap/common/attribute.c.orig    Mon Sep 21 17:11:32 1992
  2. --- dsap/common/attribute.c    Fri Sep 25 10:08:42 1992
  3. ***************
  4. *** 53,58 ****
  5. --- 53,61 ----
  6.   AttributeType at_searchacl;
  7.   AttributeType at_listacl;
  8.   AttributeType at_authpolicy;
  9. + #ifdef KERBEROS
  10. + AttributeType at_kerberosname;
  11. + #endif
  12.   OID alias_oc;
  13.   OID quipu_dsa_oid;
  14.   OID extern_obj_oid;
  15. ***************
  16. *** 90,95 ****
  17. --- 93,101 ----
  18.       at_searchacl    = AttrT_new (SEARCHACL_OID);
  19.       at_listacl      = AttrT_new (LISTACL_OID);
  20.       at_authpolicy   = AttrT_new (AUTHPOLICY_OID);
  21. + #ifdef KERBEROS
  22. +     at_kerberosname = AttrT_new (KERBEROSNAME_OID);
  23. + #endif
  24.   
  25.       at_subord     = AttrT_new (SUBORD_OID);
  26.       at_xref     = AttrT_new (XREF_OID);
  27. *** h/quipu/bind.h.orig    Tue Jun 23 17:13:11 1992
  28. --- h/quipu/bind.h    Fri Sep 25 16:21:15 1992
  29. ***************
  30. *** 25,30 ****
  31. --- 25,33 ----
  32.   #define QUIPUBIND
  33.   #include "quipu/name.h"
  34.   #include "quipu/authen.h"
  35. + #ifdef KERBEROS
  36. + #include <krb.h>
  37. + #endif
  38.   
  39.       /* THIS SECTION GIVES BIND PARAMETERS */
  40.   
  41. ***************
  42. *** 52,57 ****
  43. --- 55,61 ----
  44.       char * dba_vtmp;    /* pepsy */
  45.       int    dba_vlen;    /* pepsy */
  46.       struct alg_id dba_alg;
  47. +     struct type_UNIV_EXTERNAL *dba_external;
  48.   };
  49.   
  50.   struct ds_bind_error {
  51. ***************
  52. *** 70,74 ****
  53. --- 74,95 ----
  54.       char    dbe_data[DBE_SIZE];        /*   data */
  55.       
  56.   };
  57. + 
  58. + #ifdef KERBEROS
  59. + 
  60. + struct kerberos_parms {
  61. +     DN    kp_dn;        /* DN to bind as */
  62. + 
  63. +     int    kp_version;
  64. + #define AUTH_TYPE_KERBEROS_V4    1
  65. + #define AUTH_TYPE_KERBEROS_V5    2
  66. + 
  67. +     u_long    kp_enonce[2];
  68. + #define kp_nonce    kp_enonce[0]
  69. + 
  70. +     KTEXT_ST kp_ktxt;    /* kerberos authenticator and ticket */
  71. + };
  72. + 
  73. + #endif /* KERBEROS */
  74.   
  75.   #endif
  76. *** h/quipu/oid.h.orig    Sat Jun 27 10:39:02 1992
  77. --- h/quipu/oid.h    Fri Sep 25 10:08:43 1992
  78. ***************
  79. *** 65,70 ****
  80. --- 65,71 ----
  81.   #define SEARCHACL_OID    "0.9.2342.19200300.100.1.57"
  82.   #define LISTACL_OID    "0.9.2342.19200300.100.1.58"
  83.   #define AUTHPOLICY_OID    "0.9.2342.19200300.100.1.59"
  84. + #define KERBEROSNAME_OID    "1.3.6.1.4.1.250.1.33"
  85.   
  86.       /* Signature Algorithm */
  87.   #ifdef  OSISEC
  88. *** quipu/sys_tai.c.orig    Sat Aug 29 09:57:38 1992
  89. --- quipu/sys_tai.c    Fri Sep 25 10:08:45 1992
  90. ***************
  91. *** 61,66 ****
  92. --- 61,70 ----
  93.   #ifdef TURBO_INDEX
  94.   extern int optimized_only;
  95.   #endif
  96. + #ifdef KERBEROS
  97. + extern char *kerberos_name;
  98. + extern char *kerberos_keyfile;
  99. + #endif
  100.   
  101.   unsigned bind_policy = POLICY_ACCESS_ALL;
  102.   unsigned strong_policy = POLICY_ACCESS_ALL;
  103. ***************
  104. *** 109,114 ****
  105. --- 113,120 ----
  106.   #define GETEDB_SIZE     48
  107.   #define AUTHFILE     50
  108.   #define FASTSTART     51
  109. + #define KERBEROS_NAME     52
  110. + #define KERBEROS_KEY     53
  111.   
  112.   static  CMD_TABLE  cmdtab[] =
  113.   {
  114. ***************
  115. *** 156,161 ****
  116. --- 162,171 ----
  117.       "INDEX_SUBTREE",    INDEX_SUBTREE,
  118.       "INDEX_SIBLINGS",    INDEX_SIBLINGS,
  119.   #endif
  120. + #ifdef KERBEROS
  121. +     "KERBEROS_NAME",    KERBEROS_NAME,
  122. +     "KERBEROS_KEY",        KERBEROS_KEY,
  123. + #endif
  124.   #ifndef NO_STATS
  125.       "STATS",    STATS,
  126.   #endif
  127. ***************
  128. *** 395,400 ****
  129. --- 405,420 ----
  130.           index_siblings(arg);
  131.                   DLOG(log_dsap, LLOG_TRACE, ("Tailor index siblings %s", arg));
  132.                   break;
  133. + #endif
  134. + #ifdef KERBEROS
  135. +     case KERBEROS_NAME:
  136. +         kerberos_name = strdup( arg );
  137. +                 DLOG(log_dsap, LLOG_TRACE, ("Tailor kerberos name %s", arg));
  138. +         break;
  139. +     case KERBEROS_KEY:
  140. +         kerberos_keyfile = strdup( arg );
  141. +                 DLOG(log_dsap, LLOG_TRACE, ("Tailor kerberos keyfile %s", arg));
  142. +         break;
  143.   #endif
  144.           default:
  145.           return NOTOK;
  146. *** quipu/conn_init.c.bak    Fri Sep 25 17:18:32 1992
  147. --- quipu/conn_init.c    Fri Sep 25 17:19:08 1992
  148. ***************
  149. *** 177,182 ****
  150. --- 177,185 ----
  151.       switch(ds_bind_return)
  152.       {
  153.       case DS_OK:
  154. + #ifdef KERBEROS
  155. +     cn->cn_dn = dn_cpy(ds->ds_bind_arg.dba_dn);
  156. + #endif
  157.       conn_init_res(cn);
  158.       break;
  159.       case DS_ERROR_CONNECT:
  160. *** quipu/ds_add.c.bak    Fri Sep 25 16:30:12 1992
  161. --- quipu/ds_add.c    Fri Sep 25 16:30:57 1992
  162. ***************
  163. *** 67,72 ****
  164. --- 67,73 ----
  165.   int authp;
  166.   extern int read_only;
  167.   extern int    entry_cmp();
  168. + extern DN trust_dn();
  169.   
  170.       DLOG (log_dsap,LLOG_TRACE,("ds_add"));
  171.   
  172. ***************
  173. *** 187,193 ****
  174.       else
  175.           authp = AP_SIMPLE;
  176.   
  177. !     if (check_acl ((authtype % 3) >= authp ? binddn : NULLDN, ACL_ADD,
  178.           entryptr->e_acl->ac_child,dntop) == NOTOK) {
  179.           error->dse_type = DSE_SECURITYERROR;
  180.           error->ERR_SECURITY.DSE_sc_problem = DSE_SC_ACCESSRIGHTS;
  181. --- 188,194 ----
  182.       else
  183.           authp = AP_SIMPLE;
  184.   
  185. !     if (check_acl ( trust_dn( binddn, authtype, authp ), ACL_ADD,
  186.           entryptr->e_acl->ac_child,dntop) == NOTOK) {
  187.           error->dse_type = DSE_SECURITYERROR;
  188.           error->ERR_SECURITY.DSE_sc_problem = DSE_SC_ACCESSRIGHTS;
  189. *** quipu/ds_compare.c.bak    Fri Sep 25 16:38:20 1992
  190. --- quipu/ds_compare.c    Fri Sep 25 16:39:01 1992
  191. ***************
  192. *** 56,61 ****
  193. --- 56,62 ----
  194.   int retval;
  195.   DN realtarget;
  196.   int authp;
  197. + extern DN trust_dn();
  198.   
  199.       DLOG (log_dsap,LLOG_TRACE,("ds_compare"));
  200.   
  201. ***************
  202. *** 110,116 ****
  203.       authp = entryptr->e_authp ? entryptr->e_authp->ap_readandcompare :
  204.           AP_SIMPLE;
  205.   
  206. !     if (check_acl ((authtype % 3) >= authp ? binddn : NULLDN, ACL_COMPARE,
  207.           entryptr->e_acl->ac_entry, realtarget) == NOTOK) {
  208.           if (dsp && (check_acl (binddn,ACL_COMPARE,entryptr->e_acl->ac_entry, realtarget) == OK)) {
  209.               error->dse_type = DSE_SECURITYERROR;
  210. --- 111,117 ----
  211.       authp = entryptr->e_authp ? entryptr->e_authp->ap_readandcompare :
  212.           AP_SIMPLE;
  213.   
  214. !     if (check_acl ( trust_dn( binddn, authtype, authp ), ACL_COMPARE,
  215.           entryptr->e_acl->ac_entry, realtarget) == NOTOK) {
  216.           if (dsp && (check_acl (binddn,ACL_COMPARE,entryptr->e_acl->ac_entry, realtarget) == OK)) {
  217.               error->dse_type = DSE_SECURITYERROR;
  218. *** quipu/ds_list.c.bak    Fri Sep 25 16:33:11 1992
  219. --- quipu/ds_list.c    Fri Sep 25 16:37:18 1992
  220. ***************
  221. *** 35,40 ****
  222. --- 35,41 ----
  223.   extern LLog * log_dsap;
  224.   extern Entry database_root;
  225.   static int build_result();
  226. + extern DN trust_dn();
  227.   
  228.   do_ds_list (arg, error, result, binddn, target, di_p, dsp, authtype)
  229.       register struct ds_list_arg          *arg;
  230. ***************
  231. *** 118,124 ****
  232.       /* check parent will allow listing */
  233.       sizelimit = SVC_NOSIZELIMIT;
  234.       if ( entryptr->e_lacl != NULLAV ) {
  235. !         if ( check_lacl( (authtype % 3) >= authp ? binddn : NULLDN,
  236.               realtarget, entryptr->e_lacl, SACL_SINGLELEVEL,
  237.               &sizelimit ) == NOTOK ) {
  238.               /* security error */
  239. --- 119,125 ----
  240.       /* check parent will allow listing */
  241.       sizelimit = SVC_NOSIZELIMIT;
  242.       if ( entryptr->e_lacl != NULLAV ) {
  243. !         if ( check_lacl( trust_dn( binddn, authtype, authp ),
  244.               realtarget, entryptr->e_lacl, SACL_SINGLELEVEL,
  245.               &sizelimit ) == NOTOK ) {
  246.               /* security error */
  247. ***************
  248. *** 129,135 ****
  249.               return( DS_ERROR_REMOTE );
  250.           }
  251.       } 
  252. !     if (check_acl ((authtype % 3) >= authp ? binddn : NULLDN,
  253.           ACL_READ, entryptr->e_acl->ac_child, realtarget) != OK) {
  254.           if (dsp && (check_acl (binddn,ACL_READ, entryptr->e_acl->ac_child, realtarget) == OK)) {
  255.               error->dse_type = DSE_SECURITYERROR;
  256. --- 130,136 ----
  257.               return( DS_ERROR_REMOTE );
  258.           }
  259.       } 
  260. !     if (check_acl (trust_dn( binddn, authtype, authp ),
  261.           ACL_READ, entryptr->e_acl->ac_child, realtarget) != OK) {
  262.           if (dsp && (check_acl (binddn,ACL_READ, entryptr->e_acl->ac_child, realtarget) == OK)) {
  263.               error->dse_type = DSE_SECURITYERROR;
  264. ***************
  265. *** 156,163 ****
  266.   
  267.       dn_free (realtarget);
  268.   
  269. !     build_result (arg, entryptr, result, error,
  270. !         (authtype % 3) >= authp ? binddn : NULLDN , dsp, sizelimit);
  271.       return (DS_OK);
  272.   }
  273.   
  274. --- 157,164 ----
  275.   
  276.       dn_free (realtarget);
  277.   
  278. !     build_result (arg, entryptr, result, error, trust_dn( binddn,
  279. !         authtype, authp ), dsp, sizelimit);
  280.       return (DS_OK);
  281.   }
  282.   
  283. *** quipu/ds_modifyrdn.c.bak    Fri Sep 25 16:28:21 1992
  284. --- quipu/ds_modifyrdn.c    Fri Sep 25 16:30:04 1992
  285. ***************
  286. *** 57,62 ****
  287. --- 57,63 ----
  288.   int retval;
  289.   int authp, pauthp;
  290.   extern int read_only;
  291. + DN trust_dn();
  292.   
  293.       DLOG (log_dsap,LLOG_TRACE,("ds_modifyrdn"));
  294.   
  295. ***************
  296. *** 134,143 ****
  297.           pauthp = authp = AP_SIMPLE;
  298.       }
  299.   
  300. !     if ((check_acl ((authtype % 3) >= authp ? binddn : NULLDN, ACL_WRITE,
  301.           entryptr->e_acl->ac_entry, target) == NOTOK)
  302.           || ((entryptr->e_parent->e_data != E_TYPE_CONSTRUCTOR)
  303. !         && (check_acl ((authtype % 3) >= pauthp ? binddn : NULLDN,
  304.           ACL_WRITE,entryptr->e_parent->e_acl->ac_child, target)
  305.           == NOTOK)) ) {
  306.           error->dse_type = DSE_SECURITYERROR;
  307. --- 135,144 ----
  308.           pauthp = authp = AP_SIMPLE;
  309.       }
  310.   
  311. !     if ((check_acl ( trust_dn( binddn, authtype, authp ), ACL_WRITE,
  312.           entryptr->e_acl->ac_entry, target) == NOTOK)
  313.           || ((entryptr->e_parent->e_data != E_TYPE_CONSTRUCTOR)
  314. !         && (check_acl ( trust_dn( binddn, authtype, pauthp ),
  315.           ACL_WRITE,entryptr->e_parent->e_acl->ac_child, target)
  316.           == NOTOK)) ) {
  317.           error->dse_type = DSE_SECURITYERROR;
  318. *** quipu/ds_read.c.bak    Fri Sep 25 16:32:35 1992
  319. --- quipu/ds_read.c    Fri Sep 25 16:35:47 1992
  320. ***************
  321. *** 64,69 ****
  322. --- 64,70 ----
  323.   #endif
  324.   DN realtarget;
  325.   char authp;
  326. + extern DN trust_dn();
  327.   
  328.       DLOG (log_dsap,LLOG_TRACE,("ds_read"));
  329.   
  330. ***************
  331. *** 141,147 ****
  332.   
  333.       /* entry has got a full list of attributes,  eventually
  334.          select one required */
  335. !     if (check_acl ((authtype % 3) >= authp ? binddn : NULLDN, ACL_READ,
  336.           entryptr->e_acl->ac_entry, realtarget) == NOTOK) {
  337.           if (dsp && (check_acl (binddn,ACL_READ,entryptr->e_acl->ac_entry, realtarget) == OK)) {
  338.               error->dse_type = DSE_SECURITYERROR;
  339. --- 142,148 ----
  340.   
  341.       /* entry has got a full list of attributes,  eventually
  342.          select one required */
  343. !     if (check_acl ( trust_dn( binddn, authtype, authp ), ACL_READ,
  344.           entryptr->e_acl->ac_entry, realtarget) == NOTOK) {
  345.           if (dsp && (check_acl (binddn,ACL_READ,entryptr->e_acl->ac_entry, realtarget) == OK)) {
  346.               error->dse_type = DSE_SECURITYERROR;
  347. *** quipu/ds_remove.c.bak    Fri Sep 25 16:31:03 1992
  348. --- quipu/ds_remove.c    Fri Sep 25 16:32:05 1992
  349. ***************
  350. *** 50,55 ****
  351. --- 50,56 ----
  352.   int retval;
  353.   int authp, pauthp;
  354.   extern int read_only;
  355. + extern DN trust_dn();
  356.   
  357.       DLOG (log_dsap,LLOG_TRACE,("ds remove entry"));
  358.   
  359. ***************
  360. *** 128,136 ****
  361.       }
  362.   
  363.       if ( ((entryptr->e_parent->e_data == E_TYPE_CONSTRUCTOR)
  364. !         && (check_acl ((authtype % 3) >= authp ? binddn : NULLDN, ACL_WRITE,
  365.           entryptr->e_acl->ac_entry, target) == NOTOK))
  366. !         || (check_acl ((authtype % 3) >= pauthp ? binddn : NULLDN,
  367.           ACL_WRITE, entryptr->e_parent->e_acl->ac_child, target) == NOTOK)) {
  368.           error->dse_type = DSE_SECURITYERROR;
  369.           error->ERR_SECURITY.DSE_sc_problem = DSE_SC_ACCESSRIGHTS;
  370. --- 129,137 ----
  371.       }
  372.   
  373.       if ( ((entryptr->e_parent->e_data == E_TYPE_CONSTRUCTOR)
  374. !         && (check_acl ( trust_dn( binddn, authtype, authp ), ACL_WRITE,
  375.           entryptr->e_acl->ac_entry, target) == NOTOK))
  376. !         || (check_acl ( trust_dn( binddn, authtype, pauthp ),
  377.           ACL_WRITE, entryptr->e_parent->e_acl->ac_child, target) == NOTOK)) {
  378.           error->dse_type = DSE_SECURITYERROR;
  379.           error->ERR_SECURITY.DSE_sc_problem = DSE_SC_ACCESSRIGHTS;
  380. *** quipu/dish/bind.c.orig    Wed Jun 24 11:07:02 1992
  381. --- quipu/dish/bind.c    Thu Oct  1 13:50:33 1992
  382. ***************
  383. *** 43,48 ****
  384. --- 43,56 ----
  385.   
  386.   #include "osisec-stub.h"
  387.   
  388. + #ifdef KERBEROS
  389. + #define DEFAULT_KERBEROS_SERVICE    "x500dsa"
  390. + 
  391. + static char    *kerberos_service;
  392. + static char    *kerberos_instance;
  393. + static u_long    kerberos_nonce;
  394. + #endif
  395. + 
  396.   extern DN       fixed_pos;
  397.   DN            user_name;
  398.   
  399. ***************
  400. *** 229,234 ****
  401. --- 237,253 ----
  402.               auth_type = DBA_AUTH_SIMPLE;
  403.           else if (test_arg (argv[x], "-strong", 3))
  404.               auth_type = DBA_AUTH_STRONG;
  405. + #ifdef KERBEROS
  406. +         else if (test_arg (argv[x], "-kerberos", 3))
  407. +             auth_type = DBA_AUTH_EXTERNAL;
  408. +         else if (test_arg (argv[x], "-instance", 3)) {
  409. +             if ( ++x == argc || *argv[x] == '-' ) {
  410. +                 Usage( argv[0] );
  411. +                 return( NOTOK );
  412. +             }
  413. +             kerberos_instance = strdup( argv[x] );
  414. +         }
  415. + #endif
  416.           /* -password sets the `key', whatever the mode  */
  417.           else if (test_arg (argv[x], "-password",2)) {
  418.               got_pass = TRUE;
  419. ***************
  420. *** 301,307 ****
  421. --- 320,331 ----
  422.       else
  423.           newdn = NULLDN;
  424.   
  425. + #ifdef KERBEROS
  426. +     if (auth_type != DBA_AUTH_EXTERNAL
  427. +         && ((got_name && ! got_pass) || (*password == 0))) {
  428. + #else
  429.       if ((got_name && ! got_pass) || (*password == 0)) {
  430. + #endif
  431.           bindarg.dba_passwd_len = 0;
  432.           bindarg.dba_passwd[0]  = 0;
  433.           if ((*username != 0) && (auth_type != DBA_AUTH_NONE)) {
  434. ***************
  435. *** 314,320 ****
  436. --- 338,349 ----
  437.           (void) strcpy (bindarg.dba_passwd, password);
  438.       }
  439.   
  440. + #ifdef KERBEROS
  441. +     if ((bindarg.dba_passwd_len == 0) && (auth_type != DBA_AUTH_STRONG)
  442. +         && auth_type != DBA_AUTH_EXTERNAL)
  443. + #else
  444.       if ((bindarg.dba_passwd_len == 0) && (auth_type != DBA_AUTH_STRONG))
  445. + #endif
  446.           auth_type = DBA_AUTH_NONE;
  447.   
  448.       if (*username == 0) {
  449. ***************
  450. *** 348,353 ****
  451. --- 377,387 ----
  452.           if (sign_bindarg() != OK)
  453.               bindarg.dba_auth_type = DBA_AUTH_NONE;
  454.           break;
  455. + #ifdef KERBEROS
  456. +     case DBA_AUTH_EXTERNAL:
  457. +         kerberos_bindarg();
  458. +         break;
  459. + #endif
  460.       }
  461.   
  462.       if (isnumeric (bdsa) && (dsadn = sequence_dn (atoi (bdsa)))) {
  463. ***************
  464. *** 469,475 ****
  465.               dsa_address = myname;
  466.       }
  467.   
  468. !     if (bound) 
  469.           (void) ds_unbind ();
  470.           
  471.       bound = FALSE;
  472. --- 503,509 ----
  473.               dsa_address = myname;
  474.       }
  475.   
  476. !     if (bound)
  477.           (void) ds_unbind ();
  478.           
  479.       bound = FALSE;
  480. ***************
  481. *** 494,499 ****
  482. --- 528,545 ----
  483.           return (NOTOK);
  484.       } 
  485.       (void) signal (SIGALRM, SIG_IGN);
  486. + 
  487. + #ifdef KERBEROS
  488. +     if ( bindarg.dba_auth_type == DBA_AUTH_EXTERNAL ) {
  489. +         if ( kerberos_check_mutual( &bindresult ) == NOTOK ) {
  490. +             ps_print( OPT,
  491. +                 "*** DSA failed mutual authentication ***\n" );
  492. +             (void) ds_unbind();
  493. +             return( NOTOK );
  494. +         }
  495. +     }
  496. + #endif
  497. + 
  498.       main_dsa_id = dsap_ad;
  499.   
  500.   #ifndef NO_STATS
  501. ***************
  502. *** 955,957 ****
  503. --- 1001,1086 ----
  504.   
  505.       return (OK);
  506.   }
  507. + 
  508. + #ifdef KERBEROS
  509. + 
  510. + static kerberos_bindarg()
  511. + {
  512. +     struct type_UNIV_EXTERNAL    *e;
  513. +     struct kerberos_parms        kp;
  514. +     PE                pe;
  515. +     int                err;
  516. +     struct timeval            tv;
  517. +     char                realm[REALM_SZ];
  518. +     extern char            *psap2hostname();
  519. + 
  520. +     e = (struct type_UNIV_EXTERNAL *) calloc( 1,
  521. +         sizeof(struct type_UNIV_EXTERNAL) );
  522. +     e->encoding = (struct choice_UNIV_0 *) calloc( 1,
  523. +         sizeof(struct choice_UNIV_0) );
  524. +     bindarg.dba_external = e;
  525. +     bindarg.dba_auth_type = DBA_AUTH_EXTERNAL;
  526. + 
  527. +     e->indirect__reference = AUTH_TYPE_KERBEROS_V4;
  528. +     e->direct__reference = NULLOID;
  529. +     e->data__value__descriptor = str2qb( "KRBv4 client credentials",
  530. +         24, 1 );
  531. + 
  532. +     kp.kp_dn = bindarg.dba_dn;
  533. +     kp.kp_version = AUTH_TYPE_KERBEROS_V4;
  534. + 
  535. +     if ( kerberos_service == NULL )
  536. +         kerberos_service = DEFAULT_KERBEROS_SERVICE;
  537. +     if ( kerberos_instance == NULL ) {
  538. +         struct PSAPaddr    *pa;
  539. +         char        *p;
  540. + 
  541. +         pa = str2paddr( dsa_address, NULLNA );
  542. +         if ( (p = psap2hostname( pa )) != NULL )
  543. +             kerberos_instance = strdup( p );
  544. +         else
  545. +             kerberos_instance = "";
  546. +     }
  547. + 
  548. +     if ( (err = krb_get_tf_realm( tkt_string(), realm )) != KSUCCESS ) {
  549. +         ps_printf( OPT, "krb_get_tf_realm failed! (%s)\n",
  550. +             krb_err_txt[err]);
  551. +         return;
  552. +     }
  553. +     gettimeofday( &tv, NULL );
  554. +     kerberos_nonce = tv.tv_usec;
  555. +     if ( (err = krb_mk_req( &(kp.kp_ktxt), kerberos_service,
  556. +         kerberos_instance, realm, kerberos_nonce )) != KSUCCESS ) {
  557. +         ps_printf( OPT, "krb_mk_req failed! (%s)\n", krb_err_txt[err]);
  558. +         return;
  559. +     }
  560. + 
  561. +     if ( encode_kerberos_parms( &pe, &kp ) == NOTOK ) {
  562. +         ps_printf( OPT, "encode_kerberos_parms failed!\n" );
  563. +         return;
  564. +     }
  565. +     e->encoding->offset = choice_UNIV_0_single__ASN1__type;
  566. +     e->encoding->un.single__ASN1__type = pe;
  567. + }
  568. + 
  569. + kerberos_check_mutual( res )
  570. + struct ds_bind_arg    *res;
  571. + {
  572. +     struct type_UNIV_EXTERNAL    *e = res->dba_external;
  573. +     PE                pe;
  574. +     struct kerberos_parms        *kp;
  575. + 
  576. +     if ( e == (struct type_UNIV_EXTERNAL *) 0 )
  577. +         return( NOTOK );
  578. + 
  579. +     pe = e->encoding->un.single__ASN1__type;
  580. + 
  581. +     /* decode the kerberos authentication parameters */
  582. +     if ( decode_kerberos_parms( pe, &kp ) == NOTOK )
  583. +         return( NOTOK );
  584. +     pe_free( pe );
  585. + 
  586. +     return( kp->kp_nonce == (kerberos_nonce + 1) ? OK : NOTOK );
  587. + }
  588. + 
  589. + #endif
  590. *** quipu/ds_modify.c.bak    Thu Oct  1 13:53:32 1992
  591. --- quipu/ds_modify.c    Wed Sep 30 21:46:35 1992
  592. ***************
  593. *** 58,63 ****
  594. --- 58,91 ----
  595.   
  596.   int updateerror;
  597.   
  598. + DN trust_dn( dn, authtype, authpolicy )
  599. +     DN    dn;
  600. +     int    authtype;
  601. +     int    authpolicy;
  602. + {
  603. +     switch ( authpolicy ) {
  604. +     case AP_TRUST:
  605. +         return( dn );
  606. +         break;
  607. + 
  608. +     case AP_SIMPLE:
  609. +         return( authtype >= DBA_AUTH_SIMPLE ? dn : NULLDN );
  610. +         break;
  611. + 
  612. +     case AP_STRONG:
  613. +         return( authtype == DBA_AUTH_STRONG ||
  614. +             authtype == DBA_AUTH_EXTERNAL ? dn : NULLDN );
  615. +         break;
  616. + 
  617. +     default:
  618. +         LLOG( log_dsap, LLOG_EXCEPTIONS, ("unknown authpolicy %d",
  619. +             authpolicy) );
  620. +         break;
  621. +     }
  622. + 
  623. +     return( NULLDN );
  624. + }
  625. + 
  626.   do_ds_modifyentry (arg, error, binddn, target, di_p, dsp, authtype)
  627.       struct ds_modifyentry_arg   *arg;
  628.       struct DSError              *error;
  629. ***************
  630. *** 178,184 ****
  631.       authp = real_entry->e_authp ? real_entry->e_authp->ap_modification :
  632.           AP_SIMPLE;
  633.       if (!manager(binddn))
  634. !         effdn = (authtype % 3) >= authp ? binddn : NULLDN;
  635.       else
  636.           effdn = binddn;
  637.   
  638. --- 206,212 ----
  639.       authp = real_entry->e_authp ? real_entry->e_authp->ap_modification :
  640.           AP_SIMPLE;
  641.       if (!manager(binddn))
  642. !         effdn = trust_dn( binddn, authtype, authp );
  643.       else
  644.           effdn = binddn;
  645.   
  646. *** quipu/ds_bind.c.orig    Thu Aug 27 22:34:16 1992
  647. --- quipu/ds_bind.c    Thu Oct  1 14:27:29 1992
  648. ***************
  649. *** 38,43 ****
  650. --- 38,48 ----
  651.   
  652.   #include "osisec-stub.h"
  653.   
  654. + #ifdef KERBEROS
  655. + char    *kerberos_name;
  656. + char    *kerberos_keyfile;
  657. + #endif
  658. + 
  659.   extern LLog * log_dsap;
  660.   extern DN    mydsadn;
  661.   struct oper_act    * oper_alloc();
  662. ***************
  663. *** 91,97 ****
  664. --- 96,134 ----
  665.   /* We don't support any bilaterally-defined authentication procedures.
  666.    * Hence, if we get EXTERNAL credentials in the bind, reject them.
  667.    */
  668. + /* NOT!  We do now, if KERBEROS is defined */
  669. + #ifdef KERBEROS
  670. +     if ( arg->dba_auth_type == DBA_AUTH_EXTERNAL ) {
  671. +         int i;
  672.   
  673. +         if ( arg->dba_external->encoding->offset
  674. +             != choice_UNIV_0_single__ASN1__type ) {
  675. +             DLOG(log_dsap, LLOG_EXCEPTIONS,
  676. +                 ("Unknown EXTERNAL credentials"));
  677. +             error->dbe_version = DBA_VERSION_V1988;
  678. +             error->dbe_type = DBE_TYPE_SERVICE;
  679. +             error->dbe_value = DSE_SV_UNAVAILABLE;
  680. +             return (DS_ERROR_CONNECT);
  681. +         }
  682. +         if ( (i = kerberos_bind( arg, result, error )) == DS_OK ) {
  683. + #ifndef NO_STATS
  684. +             (void) sprintf (buff,"Bind (%d) (kerberos)",cn->cn_ad);
  685. +             pslog (log_stat,LLOG_NOTICE,buff,(IFP)dn_print,
  686. +                 (caddr_t)arg->dba_dn);
  687. + #endif
  688. +             cn->cn_authen = DBA_AUTH_EXTERNAL;
  689. +         } else {
  690. + #ifndef NO_STATS
  691. +             (void) sprintf (buff,"Bind (%d) (kerberos) (rejected)",
  692. +                 cn->cn_ad);
  693. +             pslog (log_stat,LLOG_NOTICE,buff,(IFP)dn_print,
  694. +                 (caddr_t)arg->dba_dn);
  695. + #endif
  696. +         }
  697. +         return( i );
  698. +     }
  699. + #endif KERBEROS
  700. + 
  701.       if (arg->dba_auth_type == DBA_AUTH_EXTERNAL)
  702.       {
  703.       DLOG(log_dsap, LLOG_EXCEPTIONS, ("EXTERNAL found in credentials"));
  704. ***************
  705. *** 734,737 ****
  706. --- 771,910 ----
  707.       return TRUE;
  708.   }
  709.   
  710. + #ifdef KERBEROS
  711.   
  712. + static kerberos_bind( arg, result, error )
  713. + struct ds_bind_arg        *arg;
  714. + struct ds_bind_arg        *result;
  715. + struct ds_bind_error        *error;
  716. + {
  717. +     Entry                ent;
  718. +     Attr_Sequence            as;
  719. +     AV_Sequence            av;
  720. +     AttributeValue            nameav;
  721. +     struct type_UNIV_EXTERNAL    *e = arg->dba_external;
  722. +     PE                pe;
  723. +     int                err, anyhost = 0;
  724. +     struct kerberos_parms        *kp;
  725. +     char                instance[INST_SZ], name[MAX_K_NAME_SZ];
  726. +     AUTH_DAT            ad;
  727. +     extern AttributeType        at_kerberosname;
  728. + 
  729. +     pe = e->encoding->un.single__ASN1__type;
  730. + 
  731. +     /* decode the kerberos authentication parameters */
  732. +     if ( decode_kerberos_parms( pe, &kp ) == NOTOK ) {
  733. +         DLOG( log_dsap, LLOG_EXCEPTIONS,
  734. +             ("decode_kerberos_parms failed") );
  735. +         error->dbe_version = DBA_VERSION_V1988;
  736. +         error->dbe_type = DBE_TYPE_SERVICE;
  737. +         error->dbe_value = DSE_SV_UNAVAILABLE;
  738. +         return( DS_ERROR_CONNECT );
  739. +     }
  740. +     pe_free( pe );
  741. + 
  742. +     /* check it with kerberos */
  743. +     if ( kerberos_keyfile == NULL )
  744. +         kerberos_keyfile = "";
  745. +     strcpy( instance, "*" );
  746. +     if ( kerberos_name == NULL )
  747. +         kerberos_name = "x500dsa";
  748. +     if ( (err = krb_rd_req( &kp->kp_ktxt, kerberos_name, instance, anyhost,
  749. +         &ad, kerberos_keyfile )) != KSUCCESS ) {
  750. +         DLOG( log_dsap, LLOG_NOTICE, ("krb_rd_req failed (%s)",
  751. +             krb_err_txt[err]) );
  752. +         error->dbe_version = DBA_VERSION_V1988;
  753. +         error->dbe_type  = DBE_TYPE_SECURITY;
  754. +         error->dbe_value = DSE_SC_INVALIDCREDENTIALS;
  755. +         return( DS_ERROR_CONNECT );
  756. +     }
  757. +     sprintf( name, "%s%s%s@%s", ad.pname, *ad.pinst ? "." : "", ad.pinst,
  758. +         ad.prealm );
  759. + 
  760. +     /* 
  761. +      * make sure the DN and kerberos principal correspond
  762. +      */
  763. + 
  764. +     /* find the entry */
  765. +     if ( (ent = local_find_entry( kp->kp_dn, TRUE )) == NULLENTRY ) {
  766. +         DLOG( log_dsap, LLOG_NOTICE, ("cannot find entry") );
  767. +         error->dbe_version = DBA_VERSION_V1988;
  768. +         error->dbe_type = DBE_TYPE_SERVICE;
  769. +         error->dbe_value = DSE_SV_UNAVAILABLE;
  770. +         return( DS_ERROR_CONNECT );
  771. +     }
  772. + 
  773. +     /* see if it has a kerberosName attribute */
  774. +     if ( (as = as_find_type( ent->e_attributes, at_kerberosname))
  775. +         == NULLATTR ) {
  776. +         DLOG( log_dsap, LLOG_NOTICE, ("no krbnames") );
  777. +         error->dbe_version = DBA_VERSION_V1988;
  778. +         error->dbe_type = DBE_TYPE_SECURITY;
  779. +         error->dbe_value = DSE_SC_AUTHENTICATION;
  780. +         return( DS_ERROR_CONNECT );
  781. +     }
  782. + 
  783. +     if ( (nameav = str2AttrV( name, at_kerberosname->oa_syntax ))
  784. +         == NULLAttrV ) {
  785. +         DLOG( log_dsap, LLOG_NOTICE, ("bad krbname format") );
  786. +         error->dbe_version = DBA_VERSION_V1988;
  787. +         error->dbe_type  = DBE_TYPE_SECURITY;
  788. +         error->dbe_value = DSE_SC_INVALIDCREDENTIALS;
  789. +         return( DS_ERROR_CONNECT );
  790. +     }
  791. + 
  792. +     /* see if it has the right value */
  793. +     for ( av = as->attr_value; av != NULLAV; av = av->avseq_next ) {
  794. +         if ( AttrV_cmp( av, nameav ) == 0 )
  795. +             break;
  796. +     }
  797. +     (void) AttrV_free( nameav );
  798. +     if ( av == NULLAV ) {
  799. +         DLOG( log_dsap, LLOG_NOTICE, ("krbname not found (%s)", name) );
  800. +         error->dbe_version = DBA_VERSION_V1988;
  801. +         error->dbe_type  = DBE_TYPE_SECURITY;
  802. +         error->dbe_value = DSE_SC_INVALIDCREDENTIALS;
  803. +         return( DS_ERROR_CONNECT );
  804. +     }
  805. + 
  806. +     arg->dba_dn = kp->kp_dn;
  807. + 
  808. +     /* 
  809. +      * send back mutual authentication - checksum + 1  (should be
  810. +      * encrypted in the session key XXX)
  811. +      */
  812. + 
  813. +     kp->kp_dn = mydsadn;
  814. +     ad.checksum++;
  815. +     memcpy( (char *) &(kp->kp_nonce), (char *) &(ad.checksum),
  816. +         sizeof(ad.checksum) );
  817. +     kp->kp_ktxt.length = 0;
  818. + 
  819. +     if ( encode_kerberos_parms( &pe, kp ) == NOTOK ) {
  820. +         DLOG( log_dsap, LLOG_EXCEPTIONS,
  821. +             ("encode_kerberos_parms failed") );
  822. +         error->dbe_version = DBA_VERSION_V1988;
  823. +         error->dbe_type = DBE_TYPE_SERVICE;
  824. +         error->dbe_value = DSE_SV_UNAVAILABLE;
  825. +         return( DS_ERROR_CONNECT );
  826. +     }
  827. +     free( kp );
  828. + 
  829. +     result->dba_version = DBA_VERSION_V1988;
  830. +     result->dba_auth_type = DBA_AUTH_EXTERNAL;
  831. +     result->dba_external = (struct type_UNIV_EXTERNAL *) smalloc(
  832. +         sizeof(struct type_UNIV_EXTERNAL) );
  833. +     result->dba_external->encoding = (struct choice_UNIV_0 *) smalloc(
  834. +         sizeof(struct choice_UNIV_0) );
  835. +     result->dba_external->indirect__reference = AUTH_TYPE_KERBEROS_V4;
  836. +     result->dba_external->direct__reference = NULLOID;
  837. +     result->dba_external->data__value__descriptor =
  838. +         str2qb( "KRBv4 server credentials", 24, 1 );
  839. +     result->dba_external->encoding->offset =
  840. +         choice_UNIV_0_single__ASN1__type;
  841. +     result->dba_external->encoding->un.single__ASN1__type = pe;
  842. + 
  843. +     return( DS_OK );
  844. + }
  845. + 
  846. + #endif
  847. *** dsap/x500as/das.py.orig    Wed Jun 24 10:28:40 1992
  848. --- dsap/x500as/das.py    Fri Sep 25 10:08:42 1992
  849. ***************
  850. *** 188,194 ****
  851.   
  852.   Credentials [[P struct ds_bind_arg *]]
  853.       ::=
  854. !     CHOICE <E< parm->dba_auth_type == DBA_AUTH_STRONG ? 2 : 1 >>
  855.              <D< (*parm)->dba_auth_type >>
  856.       {
  857.       simple
  858. --- 188,195 ----
  859.   
  860.   Credentials [[P struct ds_bind_arg *]]
  861.       ::=
  862. !     CHOICE <E< parm->dba_auth_type == DBA_AUTH_STRONG ? 2
  863. !         : parm->dba_auth_type == DBA_AUTH_EXTERNAL ? 3 : 1 >>
  864.              <D< (*parm)->dba_auth_type >>
  865.       {
  866.       simple
  867. ***************
  868. *** 200,206 ****
  869.       strong
  870.           [1] StrongCredentials [[p *]],
  871.       externalProcedure 
  872. !         [2] EXTERNAL [[p dba_vtmp]]
  873.       }
  874.   
  875.   -- Pulled up
  876. --- 201,208 ----
  877.       strong
  878.           [1] StrongCredentials [[p *]],
  879.       externalProcedure 
  880. !         [2] EXTERNAL [[p parm->dba_external]]
  881. ! --            [[E encode_external_type]] [[D decode_external_type]]
  882.       }
  883.   
  884.   -- Pulled up
  885. *** quipu/checkacl.c.bak    Fri Sep 25 16:33:02 1992
  886. --- quipu/checkacl.c    Thu Oct  1 16:53:41 1992
  887. ***************
  888. *** 35,40 ****
  889. --- 35,41 ----
  890.   
  891.   extern int     selector_rank[];
  892.   extern LLog    *log_dsap;
  893. + extern DN    trust_dn();
  894.   
  895.   static common_prefix_len( a, b )
  896.   char    *a;
  897. ***************
  898. *** 228,235 ****
  899.   
  900.       /* check auth policy allow us to believe binddn */
  901.       if ( e->e_authp != NULLAUTHP ) {
  902. !         binddn = (authtype % 3) >= e->e_authp->ap_listandsearch ?
  903. !             binddn : NULLDN;
  904.       }
  905.   
  906.       /* for each type in the filter */
  907. --- 229,236 ----
  908.   
  909.       /* check auth policy allow us to believe binddn */
  910.       if ( e->e_authp != NULLAUTHP ) {
  911. !         binddn = trust_dn( binddn, authtype,
  912. !             e->e_authp->ap_listandsearch );
  913.       }
  914.   
  915.       /* for each type in the filter */
  916. ***************
  917. *** 471,478 ****
  918.   
  919.       /* check auth policy allow us to believe binddn */
  920.       if ( ancestor->e_authp != NULLAUTHP ) {
  921. !         binddn = authtype >= ancestor->e_authp->ap_listandsearch ?
  922. !             binddn : NULLDN;
  923.       }
  924.   
  925.       if ( (rc = (struct result_count *) avl_find( (Avlnode *)local->st_sacls,
  926. --- 472,479 ----
  927.   
  928.       /* check auth policy allow us to believe binddn */
  929.       if ( ancestor->e_authp != NULLAUTHP ) {
  930. !         binddn = trust_dn( binddn, authtype,
  931. !             ancestor->e_authp->ap_listandsearch );
  932.       }
  933.   
  934.       if ( (rc = (struct result_count *) avl_find( (Avlnode *)local->st_sacls,
  935.